feat(hooks): classify gate results and stop counting the ones that reviewed nothing (0.8.0) - #21

Second consumer of the PreToolUse timing gap: is_docs_only, not tree_hash.
Commit 1950739 staged exactly one docs/**.md path, yet the hook emitted the
Gate-B STOP, because the commit was issued as a single Bash call whose git add
had not run when the hook read the index. Direction is safe here (a false
positive), unlike the tree_hash consumer. No fix; counts toward the row's
trigger.

Gate B skipped: behaviourally trivial (a prose occurrence note in the backlog;
no executable path changes) and the change cites no profiled story, so it keeps
the pre-existing judgement-based skip. Quality battery green: shellcheck clean,
hook tests all passed, invariant checks 123 assertions, version-bump check 36
assertions, claude plugin validate passed.

Design for the false-positive gate-pass defect: a classifier that reads the
Codex result before counting. Four classes (success / failure / backgrounded /
unrecognized), envelope-keyed, failing open with disclosure on an unrecognized
envelope. Records the four settled decisions with their reasons, the two
anchors and their disjointness, the backgrounding anchor's residual, and what
the change does not do.

Also files a follow-up todos entry for the /workflow-init preflight, kept out
of the story's scope deliberately.

Gate B N/A: no code and no prompt paths are staged. Gate B reviews a code diff,
and the routing rule forbids reviewing a document with it -- the spec's review
is Gate A (mcp__codex__exec), running next per CLAUDE.md section 5. Invariant
checks re-run clean against the new files.

Eight Gate-A passes (17, 13, 14, 4, 7, 7, 6, 6 MAJOR), every one validated.
Closed on judgement, NOT on a NO FINDINGS pass -- recorded as such in
.context/codex-reviews/gate-a-spec-CLOSURE.md, which also carries the
obligations the plan must check off.

Design changes across the cycle: a five-class classifier (success, failure,
backgrounded, no-result, unrecognized) with the class table as the single
normative definition; classification collapsed from two representations to one,
with the jq path verifying its re-encoded block occurs exactly once inside the
located span so both parser environments read the same bytes or refuse
together; no-result stated by its complement so unanticipated shapes fail
closed; malformed outer JSON reclassified as unrouteable rather than a class,
since the hook derives its own routing from that document.

Story amended four times, each recorded inline with what it replaced: §2 at
passes 2 and 5, §3 criteria at passes 4 and 8. §2 is now marked a summary
deferring to the spec, so a future amendment has one target.

todos.md: two trigger-gated rows for pre-existing conditions this design states
as contracts rather than fixes -- unserialized counter mutation, and the hook's
trust of a repository-controlled .context/.

Gate B N/A: no code or prompt paths staged. Invariant checks re-run clean.

Slot names carry no cycle-unique component, and the section 5 protocol
mandates deleting every target before each call -- correctly, since a surviving
prior file is indistinguishable from a fresh one. So a second cycle in the same
repo silently erases the first cycle's findings artifacts.

Observed rather than theorised: this cycle's Gate-A pass-1 call deleted the
2026-07-26 profiles cycle's gate-a-spec-pass-1.md, which is unrecoverable
because .context is git-ignored. Section 5 covers concurrent calls racing on one
slot; it does not cover sequential cycles reusing them.

Gate B skipped: behaviourally trivial (one backlog row; no executable path
changes) and the change cites no profiled story, so it keeps the pre-existing
judgement-based skip. Invariant checks green.

Eleven tasks, TDD steps throughout. Opens with the carried-obligations
checklist from the Gate-A closure record: seven deferred implementation
contracts (A1-A7), the shipped-doc scope discovered at spec pass 8 (B1-B3), and
three accepted residuals that must survive unchanged (C1-C3). Each names the
task that discharges it.

Ordering is load-bearing: fixtures and test helpers land before any behaviour
change, so the suite is green on both sides of the classifier; emit's status
change lands before the markers that depend on it; the shipped-doc edits land
after the behaviour they describe is real.

Carries the watch-item forward: if this plan's Gate A concentrates on A5-A7,
stop and surface rather than elaborate -- a simpler composition semantics is the
named pressure valve and that trade is decided upstream.

Gate B N/A: docs-only. Gate A on this plan runs next, per CLAUDE.md section 5.

… parser row

The result-classification story builds a POSIX awk locator with proper
string-state and backslash-parity handling. Once proven, that machine is the
likely reuse path for the escaped-quote defect in input_field's fallback rather
than inventing a second escape-aware scanner. Scopes stay separate: that story
does not touch input_field.

Gate B skipped: behaviourally trivial (a note on an existing backlog row; no
executable path changes) and the change cites no profiled story, so it keeps the
pre-existing judgement-based skip. Invariant checks green.

Spec §3.1 is amended to one locator: the jq path's in-span check needed byte
offsets jq does not report, so the span came from the scan anyway, leaving jq
as a component whose only reachable effect was downgrading an agreed result to
unrecognized. The re-encode step, the uniqueness and in-span checks and §7.3's
extraction-parity matrix are deleted with it rather than fenced off.

The plan is narrowed to contracts, tables, message pairs and per-test oracles;
the harness shell moves to Gate B as code that runs and lints.

Gate A closed at pass 9 as a pre-authorized judgement exit. The execution notes
record all 37 pass-9 findings as named Gate-B obligations, the three fixed at
closure because they would have broken execution before Gate B could observe
anything, and why nine passes never converged.

Gate B: N/A — every staged path is docs/**.md prose.

…viewed nothing

Validation evidence — docs/superpowers/stories/2026-07-30-failed-codex-call-counts-as-a-pass-story.md

battery: full quality command green — shellcheck (6 files), the hook suite 467/467 with
0 failures and 1 named skip under BOTH shells, check-invariants 123/123 + ok,
check-version-bump 36/36 + ok against BASE 0dc93d8, claude plugin validate --strict passed.
"Both shells" is now literal: HOOK_SH selects the shell the HOOK runs under, and the sh and
dash runs produce byte-identical row sets apart from the banner naming the interpreter.
An earlier draft of this entry claimed sh-and-dash while every runner invoked the hook via
`sh` — bash on macOS — so only ~7 explicit rows ever reached dash. Gate B pass 1 caught it;
the runner was parameterized rather than the claim softened.

check 1 (counterfactual for the classifier): the 0.8.0 suite and fixtures run against the
pre-change hook materialized from BASE in a temp directory. New hook: exit 0, 0 FAIL. Base
hook: exit 1, 144 FAIL (measured against the suite as it stood at that point; the suite
has grown since with the pass-2 and pass-3 oracles, so the base-hook totals are a record
of that run rather than of the current row set). Four named rows, verbatim from the base run and absent from
the new one:
  FAIL - failure/review/default/jq preserves passCount/freshCount/fingerprint/passCountA
  FAIL - failure/review/default/jq writes no gate-pass state from clean
  FAIL - backgrounded/review/default/jq writes no gate-pass state from clean
  FAIL - class: fixture shape2-executor-timeout (got [success], want [failure])
The base hook classifies every captured failure, timeout and backgrounding notice as
`success`. The invariant-1 regression is counterfactual too:
  FAIL - dash: exits 0 with a directory at the marker path (got 2)

check 2 (counterfactual for the scan rewrites, each written BEFORE its fix): timed
regression rows assert bounds and each failed first.
  FAIL - perf: 150KB payload classified within 2s (took 11s)            -> now 0s
  FAIL - perf: anchor-prefixed near miss (no-newline) within 2s (took 6s)   -> now 1s
  FAIL - perf: anchor-prefixed near miss (late-newline) within 2s (took 5s) -> now 0s
Three quadratics, each measured: `readstr` accumulated byte-by-byte while `substr(s,j,1)`
is O(len) per call in BWK awk; the `backgrounded` test ran `${b%%\n*}` on every block,
which bash 3.2 evaluates by trying successively longer suffixes; and guarding that on the
anchor prefix still left it running in full for a block that starts with the anchor and
never completes the notice — the first timed fixture began with an envelope, took the
guard's cheap path, and was blind to that branch entirely.

check 3 (correctness, found at Gate-B pass 2 and fixed here): with a pending disclosure
owed, an event name the hook could not route emitted a MALFORMED document — reproduced as
`"hookEventName":"Bogus\\","`, where the trailing backslash escapes the closing quote and
Claude Code receives invalid JSON. Two defects introduced by this diff combined:
`flush_notes` ran unconditionally so an unroutable event reached `emit`, and `$event` was
interpolated raw beside two escaped fields (the jq branch was never affected — `--arg`
encodes it). Both fixed. Five oracle rows across both runners, written before the fix and
failing first; the jq-free rows are the ones that caught the malformed document, so testing
one runner would have missed it.

check 5 (correctness, found at Gate-B pass 3 and fixed here): the tool-mapping parser
accepted any plausible token, and the mapped cases are tested BEFORE the native `Bash` and
`Skill` cases — the only two names outside `mcp__codex__*` that the hooks matcher delivers
at all. So `reviewTool=Bash` made a `git commit` COUNT a Gate-B pass instead of resetting
the cycle, and `execTool=Skill` counted a skill invocation as a Gate-A pass. Both are false
checkmarks in recorded state, reachable from a plausible typo, and this diff is what
introduced the contract they contradicted. Reproduced, fixed by requiring mapped names to
lie in the namespace, and pinned by three rows including one proving a legitimate
in-namespace mapping still counts.

check 6 (the 4096-unit notice bound, both sides): the bound that made the anchor-prefixed
near miss cheap also NARROWS the backgrounded class — a notice whose segment falls past it
counts instead of being discarded. Now tested with a genuine notice immediately inside the
cutoff (-> backgrounded) and immediately outside it (-> unrecognized), and stated in
spec §4 rather than only in the implementation comment.

check 4 (spec conformance): spec §6 fixes the composed order as disclosure first, then the
per-occurrence message. The implementation appended instead and the golden froze the
inversion. Implementation moved to match the approved spec; goldens updated.

WHAT IS NOT BOUNDED, and this entry says so rather than repeating a claim that has now
needed narrowing three times. TWO paths, not one: (a) `skipval` walks containers one
character at a time, so a large VALID sibling container before `tool_response` costs 3.2 s
at 200 KB and 11.5 s at 400 KB; (b) the record accumulator `s = s $0 "\n"` rebuilds the
whole input once per input line, so a newline-rich payload is quadratic in line count
independently of (a) — 0.35 s at 4k lines, 2.69 s at 16k. Naming only (a) was itself a
finding at pass 3: every timed row uses a large single-record payload and never reaches (b). Only the 1 Mi-unit ceiling stops that path, and a payload just under it still
costs tens of seconds. Gate-B pass 2 found this after pass 1 found the first two; the
earlier drafts of this entry claimed "the curve is now linear", generalizing from the one
shape they had measured. That claim is withdrawn: the measured shapes are bounded, the
container walk is not, and no timed row covers a branch its own fixture does not reach.

verification (named), part 1 — replay of the captured payloads through the changed hook,
9/9 rows, every row guarded on fixture-read status, sed status AND effect, the routed tool
name, the exact class and an explicit per-row expected value, with an exact row-count
check. The guards were negative-checked in three directions before the green result was
accepted: a wrong expected class, a missing fixture, and a wrong row count each fail the
step.

verification (named), part 2 — story criterion 10 was AMENDED, human-confirmed 2026-08-02,
and the amendment is in the story itself with what it gives up stated. The live probe
re-run is dropped, not deferred: it requires instrumenting the installed hook, which serves
every concurrent Claude Code session here, and no isolated profile can be driven from this
session.

awk portability — NOT established against this tree at the time of this commit. The local
battery runs one awk; CI's ubuntu runner uses mawk, and CI now runs the suite twice (sh and
dash) so that run is also the only place the locator meets a second awk implementation.
That result binds at PR time and this commit body does not carry it. 467/467 local is shell
coverage, not awk-implementation coverage.

rollback — verified by inspection, deliberately not executed, per an explicit decision
recorded 2026-08-02. The plugin cache IS version-keyed
(cache/dev-workflow-kit/dev-workflow/<version>/) and installed_plugins.json selects the
active one. 0.7.1 is PRESENT and its hook bytes are
bee47e59f9b9d682cbfc68a5db0351bf183a27fb, matching the repo bytes at 0dc93d8 — the newest
commit whose manifest still contains 0.7.1 — so that resolution method is confirmed here
empirically rather than assumed. This repo has NO tags, so "released bytes" remains a
repository-bytes claim.
NOT verified, and named rather than implied: the operator switch path. 0.8.0 has never been
installed, `claude plugin marketplace add` takes no version, and editing
installed_plugins.json is undocumented and untested. Rollback is the CURRENT state of this
machine, not a procedure anyone has run — which also means every gate-pass counter in this
cycle was maintained by 0.7.1, the hook that counts failed and backgrounded calls. The
counters are worth nothing here; each pass was judged on its findings file, per CLAUDE.md
section 5.
What a rollback costs is in the CHANGELOG, not only what it leaves behind: it restores the
original defect and the dash special-builtin exit, and it does not undo the three
diagnostic markers already in .context/.

gate B — closed clean-with-dispositions at pass 9 of 9. Pass 9 returned ZERO new
Blocker/Major on both branches; the spec branch was dispositions-only. Four findings are
dismissed with a named home in todos.md and a trigger, listed in
.context/codex-reviews/gate-b-0.8.0-dispositions.md: the two quadratic locator paths
(skipval's container walk and the record accumulator), A5 marker-matrix breadth, A6
composition breadth, and the hardening ledger's missing supersession convention. One
one-clause docs precision fix was applied after pass 9 and was NOT re-reviewed; it changed
no behaviour, prompt or test. Both pass-9 branches independently reproduced this evidence
from their own checkout rather than reading it.

What the cycle caught, each fixed with an oracle written before the fix: a denial of
service (150 KB of ordinary review text cost 10.9 s in one synchronous hook invocation,
now 0.46 s, three separate quadratics); invalid emitted JSON, where an unroutable event
plus one unescaped field produced "hookEventName":"Bogus\","; a false-checkmark
configuration hijack, where reviewTool=Bash made a git commit COUNT a Gate-B pass instead
of resetting the cycle; and a composition order that contradicted spec section 6 while its
own golden froze the inversion. Five overclaims in this evidence entry were caught and
narrowed across the nine passes.